#[cfg(test)]
pub mod test_t {

	/*
	泛型 
．泛型：提高代码复用能力
	﹣处理重复代码的问题
．泛型是具体类型或其它属性的抽象代替：
	﹣你编写的代码不是最终的代码，而是一种模板，里面有一些"占位符"。
	﹣编译器在编译时将"占位符"替换为具体的类型。
．例如：fn largest<T>(list: &[T])->T{...)
．类型参数：
	- 很短，通常一个字母
	- CamelCase
	- T:type 的缩写
	 */
    #[test]
    fn t01() {
		let arr = [1, 2, 4, 9, 1, 5, 2];
		let large = largest(&arr);
		println!("large = {}", large);

		let arr2 = vec![1, 2, 4, 9, 11, 5, 2];
		let large = largest(&arr2);
		println!("large = {}", large);
    }

	// fn funct<T>(list: &[T]) -> T {
	// 	list[0]
	// }
	
	fn largest(list: &[i32]) -> i32 {
		let mut n = list[0];
		for i in list {
			n = std::cmp::max(n, *i);
		}
		n = list[0];
		for &i in list {
			n = std::cmp::max(n, i);
		}
		n
	}

	struct Point<T, U> {
		x: T,
		y: U,
	}

	impl <T, U> Point<T, U> {
		fn x(&self) -> &T {
			&self.x
		}
		fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W>{
			Point {
				x: self.x,
				y: other.y
			}
		}
	}

	impl Point<i32, i32> {
		fn x1(&self) -> &i32 {
			&self.x
		}
	}

	/*
方法定义中的泛型 
．为 struct 或 enum实现方法的时候，可在定义中使用泛型
．注意：
	- 把T放在impl关键字后，表示在类型t上实现方法  例如：impl<T>Point<i>
	- 只针对具体类型实现方法（其余类型没实现方法） 例如：impl Point<f32>
.struct 里的泛型类型参数可以和方法的泛型类型参数不同
 */
	#[test]
    fn t02() {
		let p1 = Point {x: 12, y: 23};
		let p2 = Point {x: 12.2, y: 23.3};
		let p3 = Point {x: 12, y: 23.3};
		let p4 = p1.mixup(p2);
    }

	enum Option<T> {
		Some(T),
		None,
	}

	enum Result<T, E> {
		Ok(T),
		Err(E),
	}
	
	
	enum OptionI32 {
		Some(i32),
		None,
	}
	
	enum OptionF64 {
		Some(f64),
		None,
	}

	#[test]
    fn t03() {
		let i3 = OptionI32::Some(3);
		let f6 = OptionF64::Some(3.3);
    }
	/*
泛型代码的性能 
. 使用泛型的代码和使用具体类型的代码运行速度是一样的。
．单态化（monomorphization):
	﹣在编译时将泛型替换为具体类型的过程
 */
}
/*


Q1A

DA

മ







*/
